Spring

Spring Bean Scopes

Introduction:

Spring core container instantiates beans and manages their life-cycle. While defining a bean, we can provide its scope. Unless explicitly provided, singleton is the default scope of beans in a Spring container.

We have five types of bean scopes available in Spring. In this tutorial, we’ll explore each of them.

1. singleton:

The singleton scope ensures that there exists only a single instance of that bean per Spring IoC container. This single bean instance is stored in the cache of all singleton beans and the reference to this cached object is returned for each subsequent requests.

As we know, all Spring beans are singleton by default.

Let’s say we have a Student bean:

@Component
public class Student {

    private int id;
    private String name;

    //constructor, getters, setters

}

The Student class will be a singleton bean by default. Let’s try to load it in our main() method:

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("appContext.xml");
        Student student1 = (Student) context.getBean("student");

        student1.setName("John");
        System.out.println(student1.getName()); //Prints 'John'

        Student student2 = (Student) context.getBean("student");
        System.out.println(student2.getName()); //Prints 'John'
   }
}

Clearly, the existing instance of Student bean has been returned for the second invocation. In other words, both student1 and student2 references are pointing to the same object.

2. prototype:

For a prototype-scoped bean, a new instance is created for every request of that specific bean within our application code.

We can either configure our bean’s scope as a prototype using @Scope annotation:

@Component
@Scope("prototype")
public class Student {

    ...
}

Or when using XML-based configurations, we’ll have:

<bean id = "student" class="org.programmergirl.domain.Student"
  scope="prototype">
</bean>

Now, let’s see what happens in our main() method:

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("appContext.xml");
        Student student1 = (Student) context.getBean("student");

        student1.setName("John");
        System.out.println(student1.getName()); //Prints 'John'

        Student student2 = (Student) context.getBean("student");
        System.out.println(student2.getName()); //Prints null
   }
}

Here, student2 refers to a new instance of Student class with its name attribute as null.

Note that we should always use prototype scope for the stateful beans and singleton for the stateless beans.

3. request:

When using the request scope, a new instance is created for each and every HTTP request. The bean instance is destroyed on the HTTP request completion.

We can configure the request scope either using annotation:

@Component
@Scope("request")
public class Student {
   ...
}

//Or

@Component
@RequestScope
public class Student {
   ...
}

Or via XML configuration:

<bean id = "student" class="org.programmergirl.domain.Student"
  scope="request">
</bean>

4. session:

For a session scope, the Spring container creates a new bean instance for each HTTP session. All the HTTP requests within an HTTP session will share the same bean instance.

To configure a session-scoped bean, we’ll use:

@Component
@Scope("session")
public class Student {
   ...
}

//Or

@Component
@SessionScope
public class Student {
   ...
}

For a xml-based configurations we’ll have:

<bean id = "student" class="org.programmergirl.domain.Student"
  scope="session">
</bean>

The container will destroy the session-scoped bean instances as and when that HTTP session closes.

5. application:

With application scope, a web-aware container creates a bean instance per ServletContext. Note that the application scope is different from the singleton scope:

  • We can use the singleton scope in a standalone application. The application scope is only valid for a web-based Spring container/application
  • For singleton scope, a single instance exists per application context. On the other hand, the application-scoped bean has a single instance for the entire ServletContext. We might have multiple applications sharing the same ServletContext

Let’s configure our Student bean as an application-scoped bean:

@Component
@Scope("application")
public class Student {
   ...
}

//Or

@Component
@ApplicationScope
public class Student {
   ...
}

The xml based definition would look like:

<bean id = "student" class="org.programmergirl.domain.Student"
  scope="application"> 
</bean>

Conclusion:

In this tutorial, we explored various Spring bean scopes.

Note that the request, session and application bean scopes are only valid for a web-aware Spring ApplicationContext.

 

6 comments

I want to achieve request scope nature for a given bean but request is not a http call, it will be invoked like a normal method call, still wanted request scope nature

Can we achieve it if so how?

Hi. I coded a session scope exactly like you but I’m receiving an IllegalStateException:

org.springframework.web.util.NestedServletException: Request processing failed; nested exception is java.lang.IllegalStateException: No Scope registered for scope name ‘session’

Can you please provide me a suggestion?

Thank you in advance,

Not sure how your application is configured.
But, one possible reason for this error message could be that your Spring application might be just a standalone application.
Session scope will only be applicable for a Spring web application.

Thank you for your answer Shubhra! Yes, it’s a Spring web application.
Finally I solved the issue by using Autowired and the annotations below on the bean class:

@Service
@Scope(value=”session”, proxyMode=ScopedProxyMode.INTERFACES)

Reagrds!

Hey, you’re right.. When using @Scope annotation with web level scopes we’ll have to provide the proxy mode.

Just using @SessionScope annotation would have worked considering it has a proxy mode defaulted to TARGET_CLASS.

Thanks for your inputs here, I’ll update the article soon.

Pingback: Spring Bean Scopes | Hey Android - Android World

Leave a Comment

Your email address will not be published. Required fields are marked *