Java Tutorials Corner: Spring prototype Bean scope

In this tutorial we are going to see Spring prototype bean scope with example program.
The non-singleton, prototype scope of bean deployment results in the creation of a new bean instance every time a request for that specific bean is made. That is, the bean is injected into another bean or you request it through a getBean() method call on the container. As a rule, use the prototype scope for all stateful beans and the singleton scope for stateless beans.
The following diagram illustrates the Spring prototype scope.

Example Bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">

<bean id="prototypeBean" class="com.javatutorialscorner.spring.PrototypeBean" scope="prototype">
</bean>
</beans>

In contrast to the other scopes, Spring does not manage the complete lifecycle of a prototype bean: the container instantiates, configures, and otherwise assembles a prototype object, and hands it to the client, with no further record of that prototype instance. Thus, although initialization lifecycle callback methods are called on all objects regardless of scope, in the case of prototypes, configured destruction lifecycle callbacks are not called. The client code must clean up prototype-scoped objects and release expensive resources that the prototype bean(s) are holding. To get the Spring container to release resources held by prototype-scoped beans, try using a custom bean post-processor, which holds a reference to beans that need to be cleaned up.

In some respects, the Spring container's role in regard to a prototype-scoped bean is a replacement for the Java new operator. All lifecycle management past that point must be handled by the client.

Step by step procedure to create Spring Program using Eclipse given below.

Follow the Simple steps.

1. Select File –> New –> Java Project from your Eclipse IDE.

2.Create project called PrototypeBeanScope.

3. Add the following jars into your build path.

commons-logging-1.1.3.jar
spring-beans-3.2.6.RELEASE.jar
spring-context-3.2.6.RELEASE.jar
spring-context-support-3.2.6.RELEASE.jar
spring-core-3.2.6.RELEASE.jar
spring-expression-3.2.6.RELEASE.jar

4. Now create package com.javatutorialscorner.spring under PrototypeBeanScope Project

5. Next create PrototypeBean class under com.javatutorialscorner.spring package

PrototypeBean.java

package com.javatutorialscorner.spring;

public class PrototypeBean {
 private String sayHello;

 public void getSayHello() {
  System.out.println("Java Tutorials Corner " + sayHello);
 }

 public void setSayHello(String sayHello) {
  this.sayHello = sayHello;
 }
}

6. Now Create RunApp class which contains Bean configuration path to load configuration from Bean.xml file

RunApp.java

package com.javatutorialscorner.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class RunApp {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  
  ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
  PrototypeBean prototypeBean = (PrototypeBean)context.getBean("prototypeBean");
  prototypeBean.setSayHello("Spring Tutorial");
  prototypeBean.getSayHello();
  
  PrototypeBean prototypeBean1 = (PrototypeBean)context.getBean("prototypeBean");
  prototypeBean1.getSayHello();
 }

}

In above program

First step I created Application context using ClassPathXmlApplicationContext which load configuration from bean file which located in class path of apllication, It take care of creating and initializing all the objects (Beans) declared in bean.xml

Next getBean() method used to get particular bean from created context. This method used bean name as parameter and returns generic object. We can caste to actual object.

Once Object Created you can access any method from that class.

7. Create Bean.xml at where your class files created (ClassPathXmlApplicationContext tries to load bean file from class path).

Bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">

<bean id="prototypeBean" class="com.javatutorialscorner.spring.PrototypeBean" scope="prototype">
</bean>
</beans>

Bean.xml is default name given to bean configuration file. You can choose any name for your bean.xml but you can use file name in main application to create context and your file available in your class path must be same.

Bean.xml is used to assign unique ID to different beans and controls the creation object with different values.

Now you can run the program see the following output in console.