import com.vaadin.ui.Table;
import com.vaadin.ui.UI;
import com.vaadin.ui.Window;
+import com.vaadin.util.CurrentInstance;
import com.vaadin.util.ReflectTools;
/**
return Collections.unmodifiableCollection(requestHandlers);
}
- /**
- * Thread local for keeping track of currently used application instance
- *
- * @since 7.0
- */
- private static final ThreadLocal<Application> currentApplication = new ThreadLocal<Application>();
-
/**
* Gets the currently used application. The current application is
* automatically defined when processing requests to the server. In other
* @since 7.0
*/
public static Application getCurrent() {
- return currentApplication.get();
+ return CurrentInstance.get(Application.class);
}
/**
* @since 7.0
*/
public static void setCurrent(Application application) {
- currentApplication.set(application);
+ CurrentInstance.setInheritable(Application.class, application);
}
/**
import com.vaadin.Application;
import com.vaadin.ui.UI;
+import com.vaadin.util.CurrentInstance;
/**
* TODO Write documentation, fix JavaDoc tags.
}
private PortletResponse getCurrentResponse() {
- WrappedPortletResponse currentResponse = VaadinPortlet
- .getCurrentResponse();
+ WrappedPortletResponse currentResponse = (WrappedPortletResponse) CurrentInstance
+ .get(WrappedResponse.class);
+
if (currentResponse != null) {
return currentResponse.getPortletResponse();
} else {
}
public PortletConfig getPortletConfig() {
- return VaadinPortlet.getCurrentResponse().getDeploymentConfiguration()
- .getPortlet().getPortletConfig();
+ WrappedPortletResponse response = (WrappedPortletResponse) CurrentInstance
+ .get(WrappedResponse.class);
+ return response.getDeploymentConfiguration().getPortlet()
+ .getPortletConfig();
}
public void addPortletListener(Application app, PortletListener listener) {
import javax.servlet.http.HttpSessionBindingListener;
import com.vaadin.Application;
+import com.vaadin.util.CurrentInstance;
/**
* Web application context for Vaadin applications.
reinitializingSession = false;
// Create a new session
- HttpSession newSession = VaadinServlet.getCurrentRequest().getSession();
+ HttpSession newSession = WrappedHttpServletRequest.cast(
+ CurrentInstance.get(WrappedRequest.class)).getSession();
// Restores all attributes (security key, reference to this context
// instance)
import com.vaadin.server.AbstractCommunicationManager.Callback;
import com.vaadin.server.ServletPortletHelper.ApplicationClassException;
import com.vaadin.ui.UI;
+import com.vaadin.util.CurrentInstance;
/**
* Portlet 2.0 base class. This replaces the servlet in servlet/portlet 1.0
private PortletDeploymentConfiguration deploymentConfiguration;
private AddonContext addonContext;
- private static ThreadLocal<WrappedPortletResponse> currentResponse = new ThreadLocal<WrappedPortletResponse>();
-
@Override
public void init(PortletConfig config) throws PortletException {
super.init(config);
return deploymentConfiguration.isProductionMode();
}
- public static WrappedPortletResponse getCurrentResponse() {
- return currentResponse.get();
- }
-
protected void handleRequest(PortletRequest request,
PortletResponse response) throws PortletException, IOException {
RequestTimer requestTimer = new RequestTimer();
WrappedPortletResponse wrappedResponse = new WrappedPortletResponse(
response, getDeploymentConfiguration());
- currentResponse.set(wrappedResponse);
+ CurrentInstance.set(WrappedRequest.class, wrappedRequest);
+ CurrentInstance.set(WrappedResponse.class, wrappedResponse);
RequestType requestType = getRequestType(wrappedRequest);
}
} finally {
- UI.setCurrent(null);
- Application.setCurrent(null);
- currentResponse.set(null);
+ CurrentInstance.clearAll();
PortletSession session = request
.getPortletSession(false);
import com.vaadin.server.ServletPortletHelper.ApplicationClassException;
import com.vaadin.shared.ApplicationConstants;
import com.vaadin.ui.UI;
+import com.vaadin.util.CurrentInstance;
@SuppressWarnings("serial")
public class VaadinServlet extends HttpServlet implements Constants {
}
}
- private static ThreadLocal<WrappedHttpServletRequest> currentRequest = new ThreadLocal<WrappedHttpServletRequest>();
-
// TODO Move some (all?) of the constants to a separate interface (shared
// with portlet)
service(createWrappedRequest(request), createWrappedResponse(response));
}
- public static WrappedHttpServletRequest getCurrentRequest() {
- return currentRequest.get();
- }
-
private void service(WrappedHttpServletRequest request,
WrappedHttpServletResponse response) throws ServletException,
IOException {
RequestTimer requestTimer = new RequestTimer();
requestTimer.start();
- currentRequest.set(request);
+ CurrentInstance.set(WrappedResponse.class, response);
+ CurrentInstance.set(WrappedRequest.class, request);
AbstractApplicationServletWrapper servletWrapper = new AbstractApplicationServletWrapper(
this);
.onRequestEnd(request, response);
}
} finally {
- UI.setCurrent(null);
- Application.setCurrent(null);
- currentRequest.set(null);
+ CurrentInstance.clearAll();
HttpSession session = request.getSession(false);
if (session != null) {
import com.vaadin.shared.ui.ui.UIConstants;
import com.vaadin.shared.ui.ui.UIServerRpc;
import com.vaadin.shared.ui.ui.UIState;
+import com.vaadin.util.CurrentInstance;
import com.vaadin.util.ReflectTools;
/**
*/
protected ActionManager actionManager;
- /**
- * Thread local for keeping track of the current UI.
- */
- private static final ThreadLocal<UI> currentUI = new ThreadLocal<UI>();
-
/** Identifies the click event */
private ConnectorTracker connectorTracker = new ConnectorTracker(this);
* @see ThreadLocal
*/
public static void setCurrent(UI ui) {
- currentUI.set(ui);
+ CurrentInstance.setInheritable(UI.class, ui);
}
/**
* @see #setCurrent(UI)
*/
public static UI getCurrent() {
- return currentUI.get();
+ return CurrentInstance.get(UI.class);
}
public void setScrollTop(int scrollTop) {
--- /dev/null
+/*
+ * Copyright 2011 Vaadin Ltd.
+ *
+ * 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.vaadin.util;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Keeps track of various thread local instances used by the framework.
+ *
+ * @author Vaadin Ltd
+ * @version @VERSION@
+ * @since 7.0.0
+ */
+public class CurrentInstance {
+ private final Object instance;
+ private final boolean inheritable;
+
+ private static InheritableThreadLocal<Map<Class<?>, CurrentInstance>> instances = new InheritableThreadLocal<Map<Class<?>, CurrentInstance>>() {
+ @Override
+ protected Map<Class<?>, CurrentInstance> childValue(
+ Map<Class<?>, CurrentInstance> parentValue) {
+ Map<Class<?>, CurrentInstance> value = new HashMap<Class<?>, CurrentInstance>();
+
+ // Copy all inheritable values to child map
+ for (Entry<Class<?>, CurrentInstance> e : parentValue.entrySet()) {
+ if (e.getValue().inheritable) {
+ value.put(e.getKey(), e.getValue());
+ }
+ }
+
+ return value;
+ }
+
+ @Override
+ protected Map<java.lang.Class<?>, CurrentInstance> initialValue() {
+ return new HashMap<Class<?>, CurrentInstance>();
+ }
+ };
+
+ private CurrentInstance(Object instance, boolean inheritable) {
+ this.instance = instance;
+ this.inheritable = inheritable;
+ }
+
+ /**
+ * Gets the current instance of a specific type if available.
+ *
+ * @param type
+ * the class to get an instance of
+ * @return the current instance or the provided type, or <code>null</code>
+ * if there is no current instance.
+ */
+ public static <T> T get(Class<T> type) {
+ CurrentInstance currentInstance = instances.get().get(type);
+ if (currentInstance != null) {
+ return type.cast(currentInstance.instance);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Sets the current instance of the given type.
+ *
+ * @see #setInheritable(Class, Object)
+ * @see ThreadLocal
+ *
+ * @param type
+ * the class that should be used when getting the current
+ * instance back
+ * @param instance
+ * the actual instance
+ */
+ public static <T> void set(Class<T> type, T instance) {
+ set(type, instance, false);
+ }
+
+ /**
+ * Sets the current inheritable instance of the given type. A current
+ * instance that is inheritable will be available for child threads.
+ *
+ * @see #set(Class, Object)
+ * @see InheritableThreadLocal
+ *
+ * @param type
+ * the class that should be used when getting the current
+ * instance back
+ * @param instance
+ * the actual instance
+ */
+ public static <T> void setInheritable(Class<T> type, T instance) {
+ set(type, instance, true);
+ }
+
+ private static <T> void set(Class<T> type, T instance, boolean inheritable) {
+ if (instance == null) {
+ instances.get().remove(type);
+ } else {
+ assert type.isInstance(instance) : "Invald instance type";
+ CurrentInstance previousInstance = instances.get().put(type,
+ new CurrentInstance(instance, inheritable));
+ if (previousInstance != null) {
+ assert previousInstance.inheritable == inheritable : "Inheritable status mismatch for "
+ + type;
+ }
+ }
+ }
+
+ /**
+ * Clears all current instances.
+ */
+ public static void clearAll() {
+ instances.get().clear();
+ }
+}
<tr>
<td>assertText</td>
<td>vaadin=runcomvaadintestsapplicationThreadLocalInstances::PID_SLog_row_5</td>
- <td>11. null app in background thread</td>
+ <td>11. this app in background thread</td>
</tr>
<tr>
<td>assertText</td>
<td>vaadin=runcomvaadintestsapplicationThreadLocalInstances::PID_SLog_row_4</td>
- <td>12. null root in background thread</td>
+ <td>12. this root in background thread</td>
</tr>
<tr>
<td>assertText</td>
<tr>
<td>assertText</td>
<td>vaadin=runcomvaadintestsapplicationThreadLocalInstances::PID_SLog_row_2</td>
- <td>14. null root in resource handler</td>
+ <td>14. this root in resource handler</td>
</tr>
<tr>
<td>assertText</td>
projects / vaadin-framework.git / commitdiff