Spring bean scopes example

In Spring, bean scope is used to decide which type of bean instance should be return from Spring container back to the caller.

5 types of bean scopes supported :

  1. singleton – Return a single bean instance per Spring IoC container
  2. prototype – Return a new bean instance each time when requested
  3. request – Return a single bean instance per HTTP request. *
  4. session – Return a single bean instance per HTTP session. *
  5. globalSession – Return a single bean instance per global HTTP session. *

In most cases, you may only deal with the Spring’s core scope – singleton and prototype, and the default scope is singleton.

P.S * means only valid in the context of a web-aware Spring ApplicationContext

Singleton vs Prototype

Here’s an example to show you what’s the different between bean scope : singleton and prototype.

package com.mkyong.customer.services;
 
public class CustomerService 
{
	String message;
 
	public String getMessage() {
		return message;
	}
 
	public void setMessage(String message) {
		this.message = message;
	}
}

1. Singleton example

If no bean scope is specified in bean configuration file, default to singleton.

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
       <bean id="customerService" 
            class="com.mkyong.customer.services.CustomerService" />
 
</beans>

Run it

package com.mkyong.common;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.mkyong.customer.services.CustomerService;
 
public class App 
{
    public static void main( String[] args )
    {
    	ApplicationContext context = 
    	 new ClassPathXmlApplicationContext(new String[] {"Spring-Customer.xml"});
 
    	CustomerService custA = (CustomerService)context.getBean("customerService");
    	custA.setMessage("Message by custA");
    	System.out.println("Message : " + custA.getMessage());
 
    	//retrieve it again
    	CustomerService custB = (CustomerService)context.getBean("customerService");
    	System.out.println("Message : " + custB.getMessage());
    }
}

Output

Message : Message by custA
Message : Message by custA

Since the bean ‘customerService’ is in singleton scope, the second retrieval by ‘custB’ will display the message set by ‘custA’ also, even it’s retrieve by a new getBean() method. In singleton, only a single instance per Spring IoC container, no matter how many time you retrieve it with getBean(), it will always return the same instance.

2. Prototype example

If you want a new ‘customerService’ bean instance, every time you call it, use prototype instead.

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
   <bean id="customerService" class="com.mkyong.customer.services.CustomerService" 
         scope="prototype"/>
 
</beans>

Run it again

Message : Message by custA
Message : null

In prototype scope, you will have a new instance for each getBean() method called.

3. Bean scopes annotation

You can also use annotation to define your bean scope.

package com.mkyong.customer.services;
 
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
 
@Service
@Scope("prototype")
public class CustomerService 
{
	String message;
 
	public String getMessage() {
		return message;
	}
 
	public void setMessage(String message) {
		this.message = message;
	}
}

Enable auto component scanning

<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-2.5.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
       <context:component-scan base-package="com.mkyong.customer" />
 
</beans>

Download Source Code

Download It – Spring-Bean-Scopes-Example.zip (7 KB)

Reference

  1. http://static.springsource.org/spring/docs/2.0.x/reference/beans.html#beans-factory-scopes
Tags :

About the Author

mkyong
Founder of Mkyong.com and HostingCompass.com, love Java and open source stuff. Follow him on Twitter, or befriend him on Facebook or Google Plus. If you like my tutorials, consider make a donation to these charities.

Comments

  • Pingback: watch tv show episodes()

  • Pingback: free movie downloads()

  • Pingback: tv online, online tv()

  • Pingback: Blue Coaster33()

  • dhruva

    Good tutorials!
    valuable links too I see in comments. Thank you folks.
    but where are we setting message property values in code eg singleton case? :)

  • Ivan

    Gracias mkyong, excelentes informacion

  • http://www.defrog.it Luca

    You saved my life man!!! :)

  • Jack

    How do you access the annotation defined bean?

    I followed the above steps to make the CustomerService class @Service and @Scope(“prototype”). However, in the App.java’s main method I use the same CustomerService custA = (CustomerService)context.getBean(“customerService”);
    custA.setMessage(“Message by custA”);
    System.out.println(“Message : ” + custA.getMessage());

    It gives me the runtime exception : org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named ‘CustomerServiceAnnotation’ is defined

    • Jack

      After second thought, looks like ClassPathXmlApplicationContext is not appropriate to be context for annotation bean. Hence context.getBean(“customerService”); does not make any sense. So which context class should I use in this case?

      Many thanks

      • Sagar Dahagamwar

        You have to use : AnnotationConfigApplicationContext instead of ClassPathXmlApplicationContext. This will solve your problem

  • http://[email protected] [email protected]

    Great explanation sire .

  • Ahmed

    This link clarifies the use of

    &lt;context:annotation-config /&gt;

    and

    &lt;context:component-scan&gt;

    with a good simple example:

    http://stackoverflow.com/questions/7414794/difference-between-contextannotation-config-vs-contextcomponent-scan

  • Ahmed
  • Pingback: ??????you cannot access components belong to other desktop | MLab()

  • http://abdennour-insat.blogspot.com/ Abdennour
  • Pingback: Spring bean singleton (default )vs prototype | fatkwong14's Blog()

  • mike

    Thanks)

  • Naidu

    hi young good job .can u provide GWT And hadoop tutorials

  • ida

    Hi,
    What if I want to dispose a singleton scope bean. is that possible?
    thanks.

  • Narayan

    I facing some design challenge :-

    I have to instantiate a scoped bean after server start-up. It being a scoped bean doesn’t come up automatically.
    It is subscriber class and needs to be instantiated as soon as the server starts and it has to be scoped for the processing further.

    Thanks in advance.

  • Anonymous

    Spring 3.0 has another scope called thread Scope
    source: http://javarevisited.blogspot.sg/2012/05/what-is-bean-scope-in-spring-mvc.html

  • mty

    request – Return a single bean instance per HTTP request. *?

    It’s like prototype.

  • Anand

    Many thanks MKyong for posting great tutorials.

  • belun

    typos here:

    * what’s the diffreent between bean scopr singleton and prototype.

    • http://www.mkyong.com mkyong

      Thanks, article is updated.

  • Pingback: Spring Tutorials | Tutorials()