org.restexpress.util.RequestContext Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of RestExpress Show documentation
Internet scale, high-performance RESTful Services in Java
The newest version!
/*
    Copyright 2014, Strategic Gains, 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 org.restexpress.util;

import java.util.Hashtable;
import java.util.Map;

/**
 * The RequestContext class maintains a Map of name/value pairs much like the
 * Log4j mapped diagnostic contexts (MDC). A Request Context,
 * is an instrument for passing augmentation data from different sources to
 * lower levels in the framework.
 * 
 * 

 * The Request Context is managed on a per thread basis. A child
 * thread automatically inherits a copy of the mapped diagnostic
 * context of its parent.
 * 

 * 

 * The Request class requires JDK 1.6 or above.
 * 
 * It's best to cleanup after the request by removing the values set by that request,
 * since all threads are pooled and re-used. This can be accomplished by calling
 * RequestContext.clear() in a Postprocessor implementation.
 * 
 * 
 * @author toddf
 * @since Feb 17, 2014
 */
public class RequestContext
{
	final static RequestContext RC = new RequestContext();

	private ThreadLocal> tlm;

	private RequestContext()
	{
		tlm = new ThreadLocal>();
	}

	/**
	 * Put a context value (the o parameter) as identified with the
	 * key parameter into the current thread's context map.
	 * 
	 * 

	 * If the current thread does not have a context map it is created as a side
	 * effect.
	 */
	public static void put(String key, Object o)
	{
		RC._put(key, o);
	}

	/**
	 * Get the context identified by the key parameter.
	 * 

	 * 
	 * This method has no side effects.
	 */
	public static Object get(String key)
	{
		return RC._get(key);
	}

	/**
	 * Remove the the context identified by the key parameter.
	 */
	public static void remove(String key)
	{
		RC._remove(key);
	}

	/**
	 * Get the current thread's RequestContext as a Map. This method is intended
	 * to only be used internally.
	 */
	public static Map getContext()
	{
		return RC._getContext();
	}

	/**
	 * Remove all values from the thread's RequestContext.
	 */
	public static void clear()
	{
		RC._clear();
	}


	// SECTION: MUTATORS - INTERNAL, PRIVATE

	private void _put(String key, Object o)
	{
		Map m = tlm.get();

		if (m == null)
		{
			m = new Hashtable();
			tlm.set(m);
		}

		m.put(key, o);
	}

	private Object _get(String key)
	{
		Map m = tlm.get();

		return (m == null ? null : m.get(key));
	}

	private void _remove(String key)
	{
		Map m = tlm.get();

		if (m != null)
		{
			m.remove(key);

			if (m.isEmpty()) _clear();
		}
	}

	private Map _getContext()
	{
		return tlm.get();
	}

	private void _clear()
	{
		Map m = tlm.get();

		if (m != null)
		{
			m.clear();
			tlm.remove();
		}
	}
}