Shiro学习笔记（一）ThreadContext源码解析
最近有空，看了下shiro源码，这里写下来用以加深记忆。本篇记录下ThreadContext类的源码解析。
本篇用到的ThreadLocal及ThreadLocalMap的相关知识戳这里。
首先看下ThreadContext类的说明：
/**
* A ThreadContext provides a means of binding and unbinding objects to the
* current thread based on key/value pairs.
* <p/>
* <p>An internal {@link java.util.HashMap} is used to maintain the key/value pairs
* for each thread.</p>
* <p/>
* <p>If the desired behavior is to ensure that bound data is not shared across
* threads in a pooled or reusable threaded environment, the application (or more likely a framework) must
* bind and remove any necessary values at the beginning and end of stack
* execution, respectively (i.e. individually explicitly or all via the <tt>clear</tt> method).</p>
*
* @see #remove()
* @since 0.1
*/
public abstract class ThreadContext {ThreadContext类通过key/value键值对为每一个线程提供绑定及解绑对象的方法。如果使用了如线程池这样的技术并且不希望共享数据，那么在使用ThreadContext的开始和结束阶段都需清除数据。
/**
* Private internal log instance.
*/
private static final Logger log = LoggerFactory.getLogger(ThreadContext.class);
public static final String SECURITY_MANAGER_KEY = ThreadContext.class.getName() + "_SECURITY_MANAGER_KEY";
public static final String SUBJECT_KEY = ThreadContext.class.getName() + "_SUBJECT_KEY";
private static final ThreadLocal<Map<Object, Object>> resources = new InheritableThreadLocalMap<Map<Object, Object>>();ThreadContext的静态变量共有四个，第一个用于记录日志这个没什么好说的，第二个SECURITY_MANAGER_KEY是用来表示SecurityManager对象对应的key，SUBJECT_KEY则是表示Subject对象对应的key，这里是通过反射来定义这两个key的值。最后一个resources对象实际上就是一个ThreadLocal。通过这四行代码我们大致可以了解ThreadContext类的作用。ThreadContext的作用其实就是通过每个线程的ThreadLocalMap来存储线程自己的SecurityManager对象以及Subject对象，因为用到了ThreadLocal因此这里的操作都是线程安全地。
getResources方法
/**
* Returns the ThreadLocal Map. This Map is used internally to bind objects
* to the current thread by storing each object under a unique key.
*
* @return the map of bound resources
*/
public static Map<Object, Object> getResources() {
if (resources.get() == null){
return Collections.emptyMap();
} else {
return new HashMap<Object, Object>(resources.get());
}
}getResources方法用于返回当前线程存储在ThreadLocalMap中的HashMap对象，正常的话这个hashmap对象中应该包含有Security以及Subject对象的键值对。如果返回的hashmap为空则返回一个空的hashmap对象。
setResources方法
/**
* Allows a caller to explicitly set the entire resource map. This operation overwrites everything that existed
* previously in the ThreadContext - if you need to retain what was on the thread prior to calling this method,
* call the {@link #getResources()} method, which will give you the existing state.
*
* @param newResources the resources to replace the existing {@link #getResources() resources}.
* @since 1.0
*/
public static void setResources(Map<Object, Object> newResources) {
if (CollectionUtils.isEmpty(newResources)) {
return;
}
ensureResourcesInitialized();
resources.get().clear();
resources.get().putAll(newResources);
} private static void ensureResourcesInitialized(){
if (resources.get() == null){
resources.set(new HashMap<Object, Object>());
}
}setResources可用于设置新的map对象至resources对象也就是ThreadLocal对象中。这里首先保证新的map对象不为空，之后保证resources里的value也就是hashmap对象已经存在，然后为防止之前的数据影响，先调用clear方法清除数据然后再调用hashmap的putAll方法将新的map存入ThreadLocal对应的hashmap中。
getValue方法
/**
* Returns the value bound in the {@code ThreadContext} under the specified {@code key}, or {@code null} if there
* is no value for that {@code key}.
*
* @param key the map key to use to lookup the value
* @return the value bound in the {@code ThreadContext} under the specified {@code key}, or {@code null} if there
* is no value for that {@code key}.
* @since 1.0
*/
private static Object getValue(Object key) {
Map<Object, Object> perThreadResources = resources.get();
return perThreadResources != null ? perThreadResources.get(key) : null;
}getValue方法很简单，首先通过ThreadLocal方法的get方法获取到hashmap对象然后调用hashmap对象获取对应的value。
get方法
/**
* Returns the object for the specified <code>key</code> that is bound to
* the current thread.
*
* @param key the key that identifies the value to return
* @return the object keyed by <code>key</code> or <code>null</code> if
* no value exists for the specified <code>key</code>
*/
public static Object get(Object key) {
if (log.isTraceEnabled()) {
String msg = "get() - in thread [" + Thread.currentThread().getName() + "]";
log.trace(msg);
}
Object value = getValue(key);
if ((value != null) && log.isTraceEnabled()) {
String msg = "Retrieved value of type [" + value.getClass().getName() + "] for key [" +
key + "] " + "bound to thread [" + Thread.currentThread().getName() + "]";
log.trace(msg);
}
return value;
}getValue方法是ThreadContext私有方法而get方法则是ThreadContext类对外提供的获取值的方法，这里也什么好说的只是单纯的记录了下调用getValue方法的log。
put方法
/**
* Binds <tt>value</tt> for the given <code>key</code> to the current thread.
* <p/>
* <p>A <tt>null</tt> <tt>value</tt> has the same effect as if <tt>remove</tt> was called for the given
* <tt>key</tt>, i.e.:
* <p/>
* <pre>
* if ( value == null ) {
* remove( key );
* }</pre>
*
* @param key The key with which to identify the <code>value</code>.
* @param value The value to bind to the thread.
* @throws IllegalArgumentException if the <code>key</code> argument is <tt>null</tt>.
*/
public static void put(Object key, Object value) {
if (key == null) {
throw new IllegalArgumentException("key cannot be null");
}
if (value == null) {
remove(key);
return;
}
ensureResourcesInitialized();
resources.get().put(key, value);
if (log.isTraceEnabled()) {
String msg = "Bound value of type [" + value.getClass().getName() + "] for key [" +
key + "] to thread " + "[" + Thread.currentThread().getName() + "]";
log.trace(msg);
}
}put方法首先判断key是不是null，如果是则抛出异常。如果value是null，这里算是一个能够在正常环境中使用的小技巧，当我们想删除key对应的键值对时，可以调用put方法并将value传入null。两个基本的键值判断之后就是正常的调用hashmap的put方法获取对应的value。
remove方法
/**
* Unbinds the value for the given <code>key</code> from the current
* thread.
*
* @param key The key identifying the value bound to the current thread.
* @return the object unbound or <tt>null</tt> if there was nothing bound
* under the specified <tt>key</tt> name.
*/
public static Object remove(Object key) {
Map<Object, Object> perThreadResources = resources.get();
Object value = perThreadResources != null ? perThreadResources.remove(key) : null;
if ((value != null) && log.isTraceEnabled()) {
String msg = "Removed value of type [" + value.getClass().getName() + "] for key [" +
key + "]" + "from thread [" + Thread.currentThread().getName() + "]";
log.trace(msg);
}
return value;
}remove方法用于解绑key也就是删除key。注意这里remove方法会返回被删除的键值对。
操作SecurityManager及Subject的方法
/**
* Convenience method that simplifies retrieval of the application's SecurityManager instance from the current
* thread. If there is no SecurityManager bound to the thread (probably because framework code did not bind it
* to the thread), this method returns <tt>null</tt>.
* <p/>
* It is merely a convenient wrapper for the following:
* <p/>
* <code>return (SecurityManager)get( SECURITY_MANAGER_KEY );</code>
* <p/>
* This method only returns the bound value if it exists - it does not remove it
* from the thread. To remove it, one must call {@link #unbindSecurityManager() unbindSecurityManager()} instead.
*
* @return the Subject object bound to the thread, or <tt>null</tt> if there isn't one bound.
* @since 0.9
*/
public static SecurityManager getSecurityManager() {
return (SecurityManager) get(SECURITY_MANAGER_KEY);
}
/**
* Convenience method that simplifies binding the application's SecurityManager instance to the ThreadContext.
* <p/>
* <p>The method's existence is to help reduce casting in code and to simplify remembering of
* ThreadContext key names. The implementation is simple in that, if the SecurityManager is not <tt>null</tt>,
* it binds it to the thread, i.e.:
* <p/>
* <pre>
* if (securityManager != null) {
* put( SECURITY_MANAGER_KEY, securityManager);
* }</pre>
*
* @param securityManager the application's SecurityManager instance to bind to the thread. If the argument is
* null, nothing will be done.
* @since 0.9
*/
public static void bind(SecurityManager securityManager) {
if (securityManager != null) {
put(SECURITY_MANAGER_KEY, securityManager);
}
}
/**
* Convenience method that simplifies removal of the application's SecurityManager instance from the thread.
* <p/>
* The implementation just helps reduce casting and remembering of the ThreadContext key name, i.e it is
* merely a convenient wrapper for the following:
* <p/>
* <code>return (SecurityManager)remove( SECURITY_MANAGER_KEY );</code>
* <p/>
* If you wish to just retrieve the object from the thread without removing it (so it can be retrieved later
* during thread execution), use the {@link #getSecurityManager() getSecurityManager()} method instead.
*
* @return the application's SecurityManager instance previously bound to the thread, or <tt>null</tt> if there
* was none bound.
* @since 0.9
*/
public static SecurityManager unbindSecurityManager() {
return (SecurityManager) remove(SECURITY_MANAGER_KEY);
}
/**
* Convenience method that simplifies retrieval of a thread-bound Subject. If there is no
* Subject bound to the thread, this method returns <tt>null</tt>. It is merely a convenient wrapper
* for the following:
* <p/>
* <code>return (Subject)get( SUBJECT_KEY );</code>
* <p/>
* This method only returns the bound value if it exists - it does not remove it
* from the thread. To remove it, one must call {@link #unbindSubject() unbindSubject()} instead.
*
* @return the Subject object bound to the thread, or <tt>null</tt> if there isn't one bound.
* @since 0.2
*/
public static Subject getSubject() {
return (Subject) get(SUBJECT_KEY);
}
/**
* Convenience method that simplifies binding a Subject to the ThreadContext.
* <p/>
* <p>The method's existence is to help reduce casting in your own code and to simplify remembering of
* ThreadContext key names. The implementation is simple in that, if the Subject is not <tt>null</tt>,
* it binds it to the thread, i.e.:
* <p/>
* <pre>
* if (subject != null) {
* put( SUBJECT_KEY, subject );
* }</pre>
*
* @param subject the Subject object to bind to the thread. If the argument is null, nothing will be done.
* @since 0.2
*/
public static void bind(Subject subject) {
if (subject != null) {
put(SUBJECT_KEY, subject);
}
}
/**
* Convenience method that simplifies removal of a thread-local Subject from the thread.
* <p/>
* The implementation just helps reduce casting and remembering of the ThreadContext key name, i.e it is
* merely a convenient wrapper for the following:
* <p/>
* <code>return (Subject)remove( SUBJECT_KEY );</code>
* <p/>
* If you wish to just retrieve the object from the thread without removing it (so it can be retrieved later during
* thread execution), you should use the {@link #getSubject() getSubject()} method for that purpose.
*
* @return the Subject object previously bound to the thread, or <tt>null</tt> if there was none bound.
* @since 0.2
*/
public static Subject unbindSubject() {
return (Subject) remove(SUBJECT_KEY);
}这里6个方法就是ThreadContext所提供的6个核心方法，getXXX方法用于返回指定的对象，bind方法用于将对应的值即SecurityManager对象及Subject对象存入线程的ThreadLocalMap对象中，unbind方法则用于清除SecurityManager对象及Subject对象。
最后总结一张ThreadContext类和线程的关系。