Both classes extend Counter used by the singleton and prototype beans in the XML test. The singleton example only defines the @Component annotation. Since it doesn't pass a value into it, it uses the class name as the bean name when it's registered with the IoC container.

                    
/**
 * Annotation-based configuration of singleton <code>Counter</code>.
 */
@Component
public class SingletonCounter extends Counter {
}
                    
                

The PrototypeCounter class is a prototype bean because of the @Scope(“prototype”) annotation set on it.

                    
/**
 * Annotation-based configuration of prototype <code>Counter</code>.
 */
@Component
@Scope("prototype")
public class PrototypeCounter extends Counter {
}
                    
                

This configuration file is quite different compared to the other one defining the singletonCounter and prototypeCounter beans as bean elements in the XML. Notice that the context namespace was added to the XML declaration. Only the base package we want Spring to scan for annotated classes needs to be set on context:component-scan.

                    
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:context="http://www.springframework.org/schema/context"
             xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd">
               
    <!-- Scan context package for any eligible annotation configured beans. -->
    <context:component-scan base-package="org.springbyexample.springindepth.chapter03.scope.context" />

</beans>
                    
                

This example creates a custom thread scope. This excerpt from the ThreadScope implementation shows the key Scope implementation methods of get(String, ObjectFactory), remove(String), and registerDestructionCallback(String, Runnable). The get method gets the current bean Map from ThreadScopeAttributes. This is the Map used to cache beans during the life of a thread scoped bean. If the bean being requested is in the Map, it will be returned. Otherwise the ObjectFactory will be used to create the bean, store it in the Map, and return it. The remove method can remove a bean from the cache and the registerDestructionCallback method registers any bean that should receive a destruction callback.

                    
/**
 * Gets bean from scope.
 */
public Object get(String name, ObjectFactory factory) {
    Object result = null;
    
    Map<String, Object> hBeans = ThreadScopeContextHolder.currentThreadScopeAttributes().getBeanMap();
    
    if (!hBeans.containsKey(name)) {
        result = factory.getObject();
        
        hBeans.put(name, result);
    } else {
        result = hBeans.get(name);
    }
    
    
    return result;
}

/**
 * Removes bean from scope.
 */
public Object remove(String name) {
    Object result = null;
    
    Map<String, Object> hBeans = ThreadScopeContextHolder.currentThreadScopeAttributes().getBeanMap();

    if (hBeans.containsKey(name)) {
        result = hBeans.get(name);
        
        hBeans.remove(name);
    }

    return result;
}

public void registerDestructionCallback(String name, Runnable callback) {
    ThreadScopeContextHolder.currentThreadScopeAttributes().registerRequestDestructionCallback(name, callback);
}
                    
                

The ThreadScopeContextHolder contains methods for accessing the ThreadScopeAttributes. The ThreadScopeAttributes is stored in a ThreadLocal. This provides a thread-local variable that is unique to each thread. Each thread will have it's own ThreadScopeAttributes and since only one thread at a time can access the Map there isn't any need to worry about synchronization issues. When ThreadLocal is initialized, the initialValue() method is overridden to return an instance of ThreadScopeAttributes for the ThreadLocal to store.

                    
public class ThreadScopeContextHolder {
    
    private static final ThreadLocal<ThreadScopeAttributes> threadScopeAttributesHolder = 
	new InheritableThreadLocal<ThreadScopeAttributes>() {
        protected ThreadScopeAttributes initialValue() {
            return new ThreadScopeAttributes();
        }
    };

    /**
     * Gets <code>ThreadScopeAttributes</code>.
     */
    public static ThreadScopeAttributes getThreadScopeAttributes() {
        return threadScopeAttributesHolder.get();
    }

    /**
     * Sets <code>ThreadScopeAttributes</code>.
     */
    public static void setThreadScopeAttributes(ThreadScopeAttributes accessor) {
        ThreadScopeContextHolder.threadScopeAttributesHolder.set(accessor);
    }

    /**
     * Gets current <code>ThreadScopeAttributes</code>.
     */
    public static ThreadScopeAttributes currentThreadScopeAttributes() throws IllegalStateException {
        ThreadScopeAttributes accessor = threadScopeAttributesHolder.get();
        
        if (accessor == null) {
            throw new IllegalStateException("No thread scoped attributes.");
        }
        
        return accessor;
    }

}
                    
                

ThreadScopeAttributes contains a cache for thread scoped beans and also maintains what beans should have destruction callbacks processed when the scope ends. There is also a clear() method for processing any beans registered for destruction callbacks and clearing the cache.

                    
public class ThreadScopeAttributes {
    
    final Logger logger = LoggerFactory.getLogger(ThreadScopeAttributes.class);
    
    protected final Map<String, Object> hBeans = new HashMap<String, Object>();
    protected final Map<String, Runnable> hRequestDestructionCallbacks = new LinkedHashMap<String, Runnable>();

    /**
     * Gets bean <code>Map</code>.
     */
    protected final Map<String, Object> getBeanMap() {
        return hBeans;
    }

    /**
     * Register the given callback as to be executed after request completion.
     * 
     * @param   name        The name of the bean.
     * @param   callback    The callback of the bean to be executed for destruction.
     */
    protected final void registerRequestDestructionCallback(String name, Runnable callback) {
        Assert.notNull(name, "Name must not be null");
        Assert.notNull(callback, "Callback must not be null");
        
        hRequestDestructionCallbacks.put(name, callback);
    }

    /**
     * Clears beans and processes all bean destruction callbacks.
     */
    protected final void clear() {
        processDestructionCallbacks();
        
        hBeans.clear();   
    }

    /**
     * Processes all bean destruction callbacks.
     */
    private final void processDestructionCallbacks() {
        for (String name: hRequestDestructionCallbacks.keySet()) {
            Runnable callback = hRequestDestructionCallbacks.get(name);
            
            logger.debug("Performing destruction callback for '" + name + "' bean" + 
                     " on thread '" + Thread.currentThread().getName() + "'.");
            
            callback.run();
        }
        
        hRequestDestructionCallbacks.clear();
    }

}
                    
                

A lot of the time you will probably be using thread scopes with a pool of threads. In that case you really want any thread scoped beans to be cleared when when the current Runnable finishes. The ThreadScopeRunnable wraps another Runnable and after it finishes running, processes any destruction callbacks and also clears any cached beans.

                    
public class ThreadScopeRunnable implements Runnable {
    
    protected Runnable target = null;

    /**
     * Constructor
     */
    public ThreadScopeRunnable(Runnable target) {
        this.target = target;
    }

    /**
     * Runs <code>Runnable</code> target and 
     * then afterword processes thread scope 
     * destruction callbacks.
     */
    public final void run() {
        try {
            target.run();
        } finally {
            ThreadScopeContextHolder.currentThreadScopeAttributes().clear();
        }
    }
    
}
                    
                

The first bean definition creates a thread scoped counter. The second bean definition creates another thread scoped counter that implements the DisposableBean interface. The third bean definition creates a thread scoped bean that uses the bean element's destroy-method attribute. The second and third bean will both have destruction callbacks registered with ThreadScope. So when they are run in a ThreadScopeRunnable their destruction methods will be processed.

The fourth bean definition registers the custom thread scope using the CustomScopeConfigurer. Notice that the key's value is 'thread', which can then be used by other beans to signify this scope. The last definition is the thread pool used in some of the unit tests.

                    
<bean id="threadCounter" 
      class="org.springbyexample.springindepth.chapter03.scope.Counter" 
      scope="thread" />

<bean id="disposableThreadCounter" 
      class="org.springbyexample.springindepth.chapter03.scope.DisposableCounter" 
      scope="thread" />

<bean id="xmlDisposableThreadCounter" 
      class="org.springbyexample.springindepth.chapter03.scope.Counter" 
      scope="thread" 
      destroy-method="reset" />

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
    <property name="scopes">
        <map>
            <entry key="thread">
                <bean class="org.springbyexample.springindepth.chapter03.scope.custom.ThreadScope"/>
            </entry>
        </map>
    </property>
</bean>

<bean id="taskExecutor"
    class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="corePoolSize" value="5" />
    <property name="maxPoolSize" value="10" />
    <property name="queueCapacity" value="30" />
    <property name="threadFactory">
       <bean class="org.springframework.scheduling.concurrent.CustomizableThreadFactory">
            <property name="threadNamePrefix" value="taskExecutor-" />
       </bean>
    </property>
</bean>