Wednesday, November 19, 2014

Spring Custom Scope

Spring framework is one of the DI frameworks which is largely used to develop web applications(enterprise). It provides almost every feature which is required to develop a enterprise web application. Also it is extendable, so you can customize it the way it suits for your application.

Custom bean scope

Although bean scopes provided by Spring fulfills requirements of the application, some times you may need something different which is not available by default. In our application we faced the same situation.


We had a requirement of the scope which uses an application value to decide which bean to use(return). The default scopes provided by Spring were not useful and was not providing the required functionality.


As I said earlier, Spring is extendable. It provides an interface Scope, which you can implement to introduce custom scope in your application.

To create custom scope, Scope interface needs to be implemented. Scope interface has following methods -

  1. get - This is where bean is created if already not present in the scope. Depending upon your requirement you can change this behavior.
  2. remove - This method should remove the object from the scope with specified identifier.
  3. getConversationId - This method should return the conversation id or key which maps to the store where the beans in the current scope are maintained.
  4. registerDestructionCallback - This method should register/store the callbacks which should be executed when the bean in this scope is destroyed or when the scope is destroyed.
  5. resolveContextualReference - This method should return the contextual reference to the object.


Following code snippet shows Spring custom scope example

public class SpringCustomScope implements Scope, BeanFactoryAware {
private ConcurrentHashMap springCustomScopeBeanMap = new ConcurrentHashMap<>();
private Object initLockObject = new Object();
private BeanFactory beanFactory;
public Object get(String name, ObjectFactory objectFactory) {
Object beanObject = springCustomScopeBeanMap.get(name);
if(beanObject == null){
synchronized (initLockObject) {
                              // you may use double null check
                              // initialize your bean here
                              beanObject = objectFactory.getObject();
                              springCustomScopeBeanMap.put(name, beanObject);
return beanObject;

public Object remove(String name) {
// Not supported in this scope

public void registerDestructionCallback(String name, Runnable callback) {

public Object resolveContextualObject(String key) {
return null;

public String getConversationId() {
return "customScope";

public void setBeanFactory(BeanFactory beanFactory) throws BeansException         {
this.beanFactory = beanFactory;


In above example, SpringCustomScope implements BeanFactoryAware interface which is not required at all. In our case we needed some other beans as well to decide the bean for the current scope.

There are two ways to register your custom scope.

1. Using xml declaration -

  <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
        <property name="scopes">
                <entry key="customscope">
                    <bean class="com.yourcompany.package.SpringCustomScope">

2. Programmatically - 

 Scope threadScope= new CustomThreadScope();
 beanFactory.registerScope("customThread", threadScope);

That's all. Your custom scope is ready and can be used by writing -

<bean name="myBeanName" class="com.yourcompany.package.SomeImportantBean" scope="customscope" >

No comments:

Post a Comment

Ads Inside Post