Comprehensive Guide to Understand Spring Bean Scopes

What is Spring Bean?

Bean Scopes in Spring:

• Singleton: Per Spring IoC container, only one instance of a single bean definition will be generated, and the same object will be shared for each request made for that bean. The default scope of a bean is singleton.
• Prototype: Each time a request is made for a single bean definition, a new instance will be generated.
• Request: Each time an HTTP request for a single bean definition is made, a new instance is generated for that bean. However, this is only usable when using a web-aware Spring ApplicationContext.
• Session: A single bean definition is scoped to an HTTP Session's lifecycle. However, this is only usable when using a web-aware Spring ApplicationContext.
• Global-Session: A single bean definition is scoped to an global HTTP Session's lifecycle. However, this is only usable when using a web-aware Spring ApplicationContext.

Singleton Scope:

Example:

// JAVA CODE
package bean;
public class Sample{
    public int value;
  
    //A setter method to set the value
    public void setValue(int data)
    {
        this.value = data;
    }
  
    //A getter method to get the value
    public String getValue()
    {
        return value;
    }
}

<!-- XML CODE -->
<!DOCTYPE beans PUBLIC
     "-//SPRING//DTD BEAN 2.0//EN"
     "//www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
     < bean
         id = "id1"
         class= "bean.Sample"
         scope = "singleton" / >
</beans>

// JAVA CODE
package driver;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import bean.Sample;
  
public class User {
  
    public static void main(String[] args)
    {
        // Loading the XML configuration file
        ApplicationContext appContext = new ClassPathXmlApplicationContext( "resources/SampleXML.xml");
        Sample obj1 = (Sample)appContext.getBean("id1");
        obj1.setValue(10);
        System.out.println("The value for object obj1 is :" + obj1.getValue());
        Sample obj2 = (Sample)appContext.getBean("id1");
        System.out.println("The value for object obj2 is :" + obj2.getValue());
        if(obj1 == obj2)
        {
            System.out.println("Both obj1 and obj2 are pointing to the same object.");
        }
        else
        {
            System.out.println("obj1 and obj2 are different objects.");
        }
        System.out.println("The address of object obj1 is :" + obj1);
        System.out.println("The address of object obj2 is :" + obj2);

    }
}

Output:

Explanation:

Prototype Scope:

Example:

// JAVA CODE
package bean;
public class Sample{
    public int value;
  
    //A setter method to set the value
    public void setValue(int data)
    {
        this.value = data;
    }
  
    //A getter method to get the value
    public String getValue()
    {
        return value;
    }
}

<!-- XML CODE -->
<!DOCTYPE beans PUBLIC
     "-//SPRING//DTD BEAN 2.0//EN"
     "//www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
     < bean
         id = "id1"
         class= "bean.Sample"
         scope = "prototype" / >
</beans>

// JAVA CODE
package driver;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import bean.Sample;
  
public class User {
  
    public static void main(String[] args)
    {
        // Loading the XML configuration file
        ApplicationContext appContext = new ClassPathXmlApplicationContext( "resources/SampleXML.xml");
        Sample obj1 = (Sample)appContext.getBean("id1");
        obj1.setValue(10);
        System.out.println("The value for object obj1 is :" + obj1.getValue());
        Sample obj2 = (Sample)appContext.getBean("id1");
        System.out.println("The value for object obj2 is :" + obj2.getValue());
        if(obj1 == obj2)
        {
            System.out.println("Both obj1 and obj2 are pointing to the same object.");
        }
        else
        {
            System.out.println("obj1 and obj2 are different objects.");
        }
        System.out.println("The address of object obj1 is :" + obj1);
        System.out.println("The address of object obj2 is :" + obj2);

    }
}

Output:

Explanation:

We can clearly see that since the scope property in the bean was set to “prototype”, a new instance of the bean has been instantiated whenever a new request is made by the user.

Interview Questions on Spring Bean:

Q1. Briefly explain the three ways of implementing the lifecycle of a bean.

Ans. The three ways of implementing the lifecycle of a bean are:

• Through XML: In this technique, we must register custom init() and destroy() methods for a bean in the Spring XML configuration file when defining the bean.
• Using Programmatic Approach: To give the generated bean, the ability to call a custom init() method on the start of a spring container and a custom destroy() method on the close of the container, we must incorporate our bean with two interfaces, InitializingBean and DisposableBean, and override the afterPropertiesSet() and destroy() methods. The afterPropertiesSet() method is called when the container first starts and the bean is formed, while the destroy() method is called when the container is closed.
• Using Annotation: To give the generated bean the ability to call a custom init() method on a spring container's startup and to call a custom destroy() method on the container's closure, we need to annotate the init() method with the @PostConstruct annotation and the destroy() method with the @PreDestroy annotation.

Q2. What are inner beans in spring?

Ans. Only when a bean is used as a property of some other bean can it be deemed as an inner bean. Spring's XML-based configuration metadata allows you to define a bean by using the bean> element inside the property> or constructor-arg> elements. Inner beans are always anonymous, and their scope is always prototype.

Q3. What are stateful and stateless beans?

Ans. Stateless beans are singleton beans that are initialised only once. They possess a shared state.

Q4. List the differences between singleton scope and prototype scope.

Singleton:

• Only one object is generated for a single bean definition per Spring IoC container. Same object is shared for each request made for that bean.
• The scope of a bean is singleton by default. As a result, we don't have to specifically declare a bean as a singleton.
• For stateless beans, singleton scope is used.

Prototype:

• A new object is generated for a single bean definition each time a request is made for that bean. For every new request, a new object is generated.
• Since scope is not defaulted to prototype, you must specifically declare the scope of a being as prototype.
• For stateful beans, prototype scope is used.

Q5. What is bean wiring?

Ans. Bean wiring is the process of combining beans inside a Spring container. When wiring beans, the Spring container needs to learn what beans are required and how the container can use dependency injection to connect the beans.

Q6. What are BeanPostProcessor beans?

Ans. BPP bean is a unique type of bean that is generated before any other bean and interacts with the newly created ones.

Q7. What is the work of a Spring bean configuration file?

Ans. All of the beans that will be initialised by Spring Context are defined by the Spring bean configuration file. When a Spring ApplicationContext object is generated, it reads the spring bean xml file and initializes all of the beans. If the context has been initialized, it can be used to obtain various bean instances.

Q8. Discuss auto-wiring and its different modes.

Ans. Spring includes a feature that allows you to automatically detect the relationships between different beans. All of the bean dependencies can be declared in the Spring configuration file. As a result, Spring will use the BeanFactory to determine the dependencies among all of the beans in use. The Spring container will automatically wire relationships between cooperating beans. That is, by inspecting the contents of the BeanFactory, you can have Spring automatically resolve collaborators for your bean.

• no: This is the default setting, so no autowiring is allowed. Wiring should be done with explicit bean references.
• byName: It injects the object dependency based on the bean's name. It matches and connects its properties to the beans in the XML file with the same names.
• byType: It injects object dependencies based on their type. If the form of a property matches exactly one of the beans’ names in the XML file, it is matched and wired.
• constructor: It injects the dependency by invoking the class's constructor. It has a vast range of configurations to choose from.
• autodetect: The container attempts to connect using autowire by constructor first, then autowire by byType if that fails.

Q9. What are the drawbacks of autowiring?

Ans. Following are the drawbacks of autowiring:

• Properties like primitives, strings, and classes cannot be autowired.
• Since autowiring is less accurate, it is often desirable to use explicit wiring.
• Use of <constructor-arg> and <property> settings to specify dependencies will override autowiring.

Q10. Why is spring bean with default scope not thread safe?

Ans. Spring bean's default scope is singleton, which means there will only be one instance per context. Inconsistent data would result from having a bean class level variable that every thread can update. As a result, spring beans are not thread-safe in default mode.

Q11. What are the different ways to configure a Java class as a spring bean?

Ans. There are three ways to set up a class as a Spring Bean:

The most common configuration is XML Configuration. The bean element tag is used to configure a Spring Bean in an xml context file.

The @Bean annotation can be used to configure a Spring bean using Java Based Configuration. This annotation is used to initialize a spring bean with @Configuration groups.

@Component, @Service, @Repository, and @Controller annotations with classes allow Annotation Based Configuration to configure them as spring beans. To search for these classes, we'd need to have a base package location.

Q12. If an inner bean defines an id, can we access it from a spring container using that id?

Ans. No, an inner bean cannot be fetched from a spring container even if the id attribute is defined. getBean("theInnerId") fails with NoSuchBeanDefinitionException.

Q13. Discuss Spring bean inheritance.

Ans. By determining parent and child beans, a spring bean may show inheritance actions. The abstract attribute value of true is used to configure the parent beans. The parent attribute on the bean tag, with the parent bean id as its value, can be used to configure a child bean.

Q14. Explain Bean Definition Template in Spring Framework.

Ans. Bean Definition Template, also known as parent beans, are used to describe common bean definitions that are shared by other child beans without having to rewrite them. When creating a Bean Definition Template, the class attribute should be left blank and the abstract attribute should be set to valid. Since it is incomplete and clearly labelled as abstract, the parent bean cannot be initialised on its own.

Q15. When is a singleton and a prototype bean garbage collected? 

Ans. When the Spring container starts, singleton beans are made, and when the Spring container ceases, they are destroyed. The explanation for this is that the spring container retains a reference to it at all times, even if it is manually referenced elsewhere in your code.